def draft_node(state: GraphState) -> dict[str, str]:
    response = llm.invoke(
        [
            SystemMessage(
                content=(
                    "You are a concise technical writer. "
                    "Write a short first-pass response (3-5 sentences)."
                )
            ),
            HumanMessage(content=state["request"]),
        ]
    )
    return {"draft": response.content}

def critique_node(state: GraphState) -> dict[str, str]:
    response = llm.invoke(
        [
            SystemMessage(
                content=(
                    "You are a strict editor. Review the draft below for "
                    "factual accuracy, clarity, and tone.\n"
                    f"If the draft is acceptable as-is, reply with just '{APPROVAL_TOKEN}'.\n"
                    "Otherwise, list the specific issues to fix in 1-3 bullet points."
                )
            ),
            HumanMessage(
                content=(
                    f"Original request:\n{state['request']}\n\n"
                    f"Draft:\n{state['draft']}"
                )
            ),
        ]
    )
    return {"critique": str(response.content)}

def route_after_critique(
    state: GraphState,
) -> Literal["revise", "finalize"]:
    critique = state["critique"].strip()
    return "finalize" if critique.startswith(APPROVAL_TOKEN) else "revise"

def revise_node(state: GraphState) -> dict:
    response = llm.invoke(
        [
            SystemMessage(
                content=(
                    "You are the same technical writer. Rewrite your "
                    "draft to address every issue raised by the editor. "
                    "Keep the response concise."
                )
            ),
            HumanMessage(
                content=(
                    f"Original request:\n{state['request']}\n\n"
                    f"Your draft:\n{state['draft']}\n\n"
                    f"Editor's critique:\n{state['critique']}"
                )
            ),
        ]
    )
    return {"final": response.content}

def finalize_node(state: GraphState) -> dict:
    return {"final": state["draft"]}

builder = StateGraph(GraphState)
builder.add_node("draft", draft_node)
builder.add_node("critique", critique_node)
builder.add_node("revise", revise_node)
builder.add_node("finalize", finalize_node)

builder.add_edge(START, "draft")
builder.add_edge("draft", "critique")
builder.add_conditional_edges(
    "critique",
    route_after_critique,
    {"revise": "revise", "finalize": "finalize"},
)
builder.add_edge("revise", END)
builder.add_edge("finalize", END)

return builder.compile()

</details>

Here's what I see from this branch:

<img width="888" height="180" alt="Image" src="https://github.com/user-attachments/assets/ecdd0a3e-3146-4ecd-8a56-64764117e8da" />

here's what I see from OpenInference

<img width="893" height="293" alt="Image" src="https://github.com/user-attachments/assets/dee41518-835d-445b-93c7-78f334932a32" />

-----
TL;DR:

It seems we're missing agent-level spans in workflow scenarios, I'd like to make sure we didn't introduce something here that broke it or would prevent from having them in the future